{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "custom_layers.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "private_outputs": true,
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "tDnwEv8FtJm7"
      },
      "source": [
        "##### Copyright 2018 The TensorFlow Authors."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "colab_type": "code",
        "id": "JlknJBWQtKkI",
        "colab": {}
      },
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "60RdWsg1tETW"
      },
      "source": [
        "# Ozel Katmanlar"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "BcJg7Enms86w"
      },
      "source": [
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs/blob/master/site/tr/r1/tutorials/eager/custom_layers.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://github.com/tensorflow/docs/blob/master/site/tr/r1/tutorials/eager/custom_layers.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
        "  </td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "UEu3q4jmpKVT"
      },
      "source": [
        "Sinir aglarini olustururken yuksek seviye API olan 'tf.keras'i kullanmanizi tavsiye ederiz, ama bircok TensorFlow APIsi eager modunda rahatlikla kullanilabilir.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "pwX7Fii1rwsJ",
        "colab": {}
      },
      "source": [
        "from __future__ import absolute_import, division, print_function, unicode_literals\n",
        "\n",
        "import tensorflow as tf\n",
        "\n",
        "tf.enable_eager_execution()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "zSFfVVjkrrsI"
      },
      "source": [
        "## Katmanlar: kullanisli operasyonlarin bir araya geldigi setler\n",
        "\n",
        "Makine ogrenmesi modelleri icin kod yazarken degiskenleri tek tek kontrol etmek ya da operasyonlari tek tek yonetmek yerine yuksek seviyede soyut dusunmeyi tercih ederiz.\n",
        "\n",
        "Bircok makine ogrenmesi modeli basit katmanlarin ust uste binmesi ve birlestirilmesi olarak aciklanabilir. TensorFlow hem cok sayida genel katmanlar sunar hem de kendi uygulamaniza ozel katmanlari ya sifirdan ya da var olan katmanlara eklemeler yaparak kolayca olusturmanizi saglar.\n",
        "\n",
        "[Keras](https://keras.io) API'si TensorFlow icindeki tf.keras paketinden bulunabilir ve Keras katmanlari kendi modellerinizi olustururken kullanabilirsiniz.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "8PyXlPl-4TzQ",
        "colab": {}
      },
      "source": [
        "# tf.keras.layers paketinde katmanlar birer nesnedir. Katmanlari olusturmak icin,\n",
        "# nesneyi olusturmaniz yeterlidir. Bircok katman cikti boyutlarinin ya da kanallarin sayisini \n",
        "# ilk bagimsiz degisken olarak alir.\n",
        "layer = tf.keras.layers.Dense(100)\n",
        "# Girdi boyutlarinin sayisi ise katman ilk kullanildiginda anlasilabilecegi icin cogunlukla gereksizdir,\n",
        "# fakat isterseniz bunu ozellikle belirtebilirsiniz ki bu kompleks modellerde faydali olabilir\n",
        "layer = tf.keras.layers.Dense(10, input_shape=(None, 5))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Fn69xxPO5Psr"
      },
      "source": [
        "Var olan katmanlarin tam listesi icin [buraya bakiniz](https://www.tensorflow.org/api_docs/python/tf/keras/layers). Bunlardan bazilari Dense: (tam-bagli katman),\n",
        "Conv2D, LSTM, BatchNormalization, Dropout."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "E3XKNknP5Mhb",
        "colab": {}
      },
      "source": [
        "# Katmani kullanmak icin cagirmaniz yeterlidir.\n",
        "layer(tf.zeros([10, 5]))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Wt_Nsv-L5t2s",
        "colab": {}
      },
      "source": [
        "# Katmanlarin bircok kullanisli yontemleri vardir. Ornegin, butun katmandaki degiskenleri \n",
        "# `layer.variables` yontemi, egitebilir degiskenleri ise `layer.trainable_variables` \n",
        "# yontemi ile inceleyebilirsiniz. Burada ise tam-bagli bir katman agirlik ve sapma degiskenlerine sahiptir.\n",
        "layer.variables"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "6ilvKjz8_4MQ",
        "colab": {}
      },
      "source": [
        "# Degiskenlere ayni zamanda 'nice accessors' ile erisebiliriz\n",
        "layer.kernel, layer.bias"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "O0kDbE54-5VS"
      },
      "source": [
        "## Ozel katmanlari gerceklestirelim\n",
        "tf.keras.Layer sinifini kullanip gelistirmek kendi katmanlarinizi olusturmanin en iyi yoludur:\n",
        "  *  `__init__` , girdiye bagli olamayan ilklendirmeleri burda yapabilirsiniz\n",
        "  * `build`, burada girdi tensorlarinin seklini bildiginiz icin geri kalan ilkelendirmeleri yapabilirsiniz\n",
        "  * `call`, ileri hesaplamalari yapabildigimiz yer\n",
        "\n",
        "Degiskenlerinizi olusturmak icin `build` asamasini beklemenize gerek yoktur, onlari `__init__` asamasinda da olusturabilirsiniz. Fakat, `build` asamasinda olusturulan degiskenler katmanlarin uzerinde calisacagi girdilerin seklini bilme avantajina sahiptir. Degiskenlerin `__init__` evresinde olusturulmasi ise bu sekillerin ozellikle belirtilmesini gerektirir."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "5Byl3n1k5kIy",
        "colab": {}
      },
      "source": [
        "class MyDenseLayer(tf.keras.layers.Layer):\n",
        "  def __init__(self, num_outputs):\n",
        "    super(MyDenseLayer, self).__init__()\n",
        "    self.num_outputs = num_outputs\n",
        "\n",
        "  def build(self, input_shape):\n",
        "    self.kernel = self.add_variable(\"kernel\",\n",
        "                                    shape=[int(input_shape[-1]),\n",
        "                                           self.num_outputs])\n",
        "\n",
        "  def call(self, input):\n",
        "    return tf.matmul(input, self.kernel)\n",
        "\n",
        "layer = MyDenseLayer(10)\n",
        "print(layer(tf.zeros([10, 5])))\n",
        "print(layer.trainable_variables)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "tk8E2vY0-z4Z"
      },
      "source": [
        "Kullanicilar standart katmanlarin davranisina asina oldugu icin mumkun oldugunca bunlari kullanmak kodunuzun okunabilirligini ve bakimini kolaylastiracaktir. tf.keras.layers ya da tf.contrib.layers icerisinde bulunmayan bir katman kullanmak istiyorsaniz [buraya](http://github.com/tensorflow/tensorflow/issues/new) basvurmanizi ya da daha iyisi bize bir 'pull request' gondermenizi tavsiye ederiz!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Qhg4KlbKrs3G"
      },
      "source": [
        "## Modeller: katmanlarin birlestirilmesi\n",
        "\n",
        "Makine ogrenmesi modellerindeki ilginc katman benzeri seyler var olan katmanlarin birlestirilmesi ile olusturulur. Ornegin, 'resnet'teki her obek kivrimlarin, toplu normallestirmelerin ve kisa yollarin birlesmesi ile olusmustur.\n",
        "\n",
        "tf.keras.Model sinif diger katmnalari iceren katman benzeri seylerin olusturulmasinda kullanilir. tf.keras.Model sinifindan kalit alarak bunu yapabilirsiniz."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "N30DTXiRASlb",
        "colab": {}
      },
      "source": [
        "class ResnetIdentityBlock(tf.keras.Model):\n",
        "  def __init__(self, kernel_size, filters):\n",
        "    super(ResnetIdentityBlock, self).__init__(name='')\n",
        "    filters1, filters2, filters3 = filters\n",
        "\n",
        "    self.conv2a = tf.keras.layers.Conv2D(filters1, (1, 1))\n",
        "    self.bn2a = tf.keras.layers.BatchNormalization()\n",
        "\n",
        "    self.conv2b = tf.keras.layers.Conv2D(filters2, kernel_size, padding='same')\n",
        "    self.bn2b = tf.keras.layers.BatchNormalization()\n",
        "\n",
        "    self.conv2c = tf.keras.layers.Conv2D(filters3, (1, 1))\n",
        "    self.bn2c = tf.keras.layers.BatchNormalization()\n",
        "\n",
        "  def call(self, input_tensor, training=False):\n",
        "    x = self.conv2a(input_tensor)\n",
        "    x = self.bn2a(x, training=training)\n",
        "    x = tf.nn.relu(x)\n",
        "\n",
        "    x = self.conv2b(x)\n",
        "    x = self.bn2b(x, training=training)\n",
        "    x = tf.nn.relu(x)\n",
        "\n",
        "    x = self.conv2c(x)\n",
        "    x = self.bn2c(x, training=training)\n",
        "\n",
        "    x += input_tensor\n",
        "    return tf.nn.relu(x)\n",
        "\n",
        "\n",
        "block = ResnetIdentityBlock(1, [1, 2, 3])\n",
        "print(block(tf.zeros([1, 2, 3, 3])))\n",
        "print([x.name for x in block.trainable_variables])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wYfucVw65PMj"
      },
      "source": [
        "Cogunlukla bircok katmandan olusan modeller sadece katmanlari belli bir sirayla cagirirlar. Bu islem tf.keras.Sequential kullanilarak cok az bir kod ile yapilabilir."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "L9frk7Ur4uvJ",
        "colab": {}
      },
      "source": [
        " my_seq = tf.keras.Sequential([tf.keras.layers.Conv2D(1, (1, 1)),\n",
        "                               tf.keras.layers.BatchNormalization(),\n",
        "                               tf.keras.layers.Conv2D(2, 1,\n",
        "                                                      padding='same'),\n",
        "                               tf.keras.layers.BatchNormalization(),\n",
        "                               tf.keras.layers.Conv2D(3, (1, 1)),\n",
        "                               tf.keras.layers.BatchNormalization()])\n",
        "my_seq(tf.zeros([1, 2, 3, 3]))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "c5YwYcnuK-wc"
      },
      "source": [
        "# Sirada ne var\n",
        "\n",
        "Simdi bir onceki kitapciga donerek dogrusal gerileme ornegini katmanlari ve modelleri kullanarak daha iyi yapilandirabilirsiniz."
      ]
    }
  ]
}